home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Libraries / usr (gcc 1.37 libs) / mac / alloca.c < prev    next >
Text File  |  1993-10-10  |  6KB  |  234 lines
  1. /*
  2.     alloca -- (mostly) portable public-domain implementation -- D A Gwyn
  3.  
  4.     last edit:    86/05/30    rms
  5.        include config.h, since on VMS it renames some symbols.
  6.  
  7.     This implementation of the PWB library alloca() function,
  8.     which is used to allocate space off the run-time stack so
  9.     that it is automatically reclaimed upon procedure exit, 
  10.     was inspired by discussions with J. Q. Johnson of Cornell.
  11.  
  12.     It should work under any C implementation that uses an
  13.     actual procedure stack (as opposed to a linked list of
  14.     frames).  There are some preprocessor constants that can
  15.     be defined when compiling for your specific system, for
  16.     improved efficiency; however, the defaults should be okay.
  17.  
  18.     The general concept of this implementation is to keep
  19.     track of all alloca()-allocated blocks, and reclaim any
  20.     that are found to be deeper in the stack than the current
  21.     invocation.  This heuristic does not reclaim storage as
  22.     soon as it becomes invalid, but it will do so eventually.
  23.  
  24.     As a special case, alloca(0) reclaims storage without
  25.     allocating any.  It is a good idea to use alloca(0) in
  26.     your main control loop, etc. to force garbage collection.
  27. */
  28. #ifndef lint
  29. static char    SCCSid[] = "@(#)alloca.c    1.1";    /* for the "what" utility */
  30. #endif
  31.  
  32. #ifdef THINK_C
  33. void *xmalloc(long);
  34. void *xrealloc(void *, long);
  35. #ifndef TARGET_MAC
  36. #define TARGET_MAC
  37. #endif
  38. #endif
  39.  
  40. #ifdef TARGET_MAC
  41. #include <sys/types.h>
  42. #define STACK_DIRECTION -1
  43. #endif /* TARGET_MAC */
  44.  
  45. #ifdef emacs
  46. #include "config.h"
  47. #ifdef static
  48. /* actually, only want this if static is defined as ""
  49.    -- this is for usg, in which emacs must undefine static
  50.    in order to make unexec workable
  51.    */
  52. #ifndef STACK_DIRECTION
  53. you
  54. lose
  55. -- must know STACK_DIRECTION at compile-time
  56. #endif /* STACK_DIRECTION undefined */
  57. #endif static
  58. #endif emacs
  59.  
  60. #ifdef X3J11
  61. typedef void    *pointer;        /* generic pointer type */
  62. #else
  63. typedef char    *pointer;        /* generic pointer type */
  64. #endif
  65.  
  66. #ifndef NULL
  67. #define    NULL    0            /* null pointer constant */
  68. #endif
  69.  
  70. #include <stdlib.h>
  71.  
  72. /*
  73.     Define STACK_DIRECTION if you know the direction of stack
  74.     growth for your system; otherwise it will be automatically
  75.     deduced at run-time.
  76.  
  77.     STACK_DIRECTION > 0 => grows toward higher addresses
  78.     STACK_DIRECTION < 0 => grows toward lower addresses
  79.     STACK_DIRECTION = 0 => direction of growth unknown
  80. */
  81.  
  82. #ifndef STACK_DIRECTION
  83. #define    STACK_DIRECTION    0        /* direction unknown */
  84. #endif
  85.  
  86. #if STACK_DIRECTION != 0
  87.  
  88. #define    STACK_DIR    STACK_DIRECTION    /* known at compile-time */
  89.  
  90. #else    /* STACK_DIRECTION == 0; need run-time code */
  91.  
  92. static int    stack_dir;        /* 1 or -1 once known */
  93. #define    STACK_DIR    stack_dir
  94.  
  95. static void
  96. find_stack_direction (/* void */)
  97. {
  98.   static char    *addr = NULL;    /* address of first
  99.                    `dummy', once known */
  100.   auto char    dummy;        /* to get stack address */
  101.  
  102.   if (addr == NULL)
  103.     {                /* initial entry */
  104.       addr = &dummy;
  105.  
  106.       find_stack_direction ();    /* recurse once */
  107.     }
  108.   else                /* second entry */
  109.     if (&dummy > addr)
  110.       stack_dir = 1;        /* stack grew upward */
  111.     else
  112.       stack_dir = -1;        /* stack grew downward */
  113. }
  114.  
  115. #endif    /* STACK_DIRECTION == 0 */
  116.  
  117. /*
  118.     An "alloca header" is used to:
  119.     (a) chain together all alloca()ed blocks;
  120.     (b) keep track of stack depth.
  121.  
  122.     It is very important that sizeof(header) agree with malloc()
  123.     alignment chunk size.  The following default should work okay.
  124. */
  125.  
  126. #ifndef    ALIGN_SIZE
  127. #define    ALIGN_SIZE    sizeof(double)
  128. #endif
  129.  
  130. typedef union hdr
  131. {
  132.   char    align[ALIGN_SIZE];    /* to force sizeof(header) */
  133.   struct
  134.     {
  135.       union hdr *next;        /* for chaining headers */
  136.       char *deep;        /* for stack depth measure */
  137.     } h;
  138. } header;
  139.  
  140. /*
  141.     alloca( size ) returns a pointer to at least `size' bytes of
  142.     storage which will be automatically reclaimed upon exit from
  143.     the procedure that called alloca().  Originally, this space
  144.     was supposed to be taken from the current stack frame of the
  145.     caller, but that method cannot be made to work for some
  146.     implementations of C, for example under Gould's UTX/32.
  147. */
  148.  
  149. static header *last_alloca_header = NULL; /* -> last alloca header */
  150.  
  151. #ifdef TARGET_MAC
  152. #ifdef THINK_C
  153. #define PROBE probef()
  154. char *probef(void) = 0x2016;
  155. #else
  156. #ifdef __GNUC__
  157. #define PROBE probef()
  158. extern inline char *probef(void)
  159.     {
  160.     register char *result asm("d0");
  161.     asm volatile (".word 0x2016":::"d0");
  162.     return result;
  163.     }
  164. #else
  165. #define PROBE &probe
  166. #endif
  167. #endif
  168. #endif
  169.  
  170. void *alloca (size_t size)            /* returns pointer to storage */
  171. {
  172.   auto char    probe;        /* probes stack depth: */
  173. #ifndef TARGET_MAC
  174.   register char    *depth = &probe;
  175. #else
  176.   register char    *depth = PROBE;
  177. #endif /* TARGET_MAC */
  178.  
  179. #if STACK_DIRECTION == 0
  180.   if (STACK_DIR == 0)        /* unknown growth direction */
  181.     find_stack_direction ();
  182. #endif
  183.  
  184.                 /* Reclaim garbage, defined as all alloca()ed storage that
  185.                    was allocated from deeper in the stack than currently. */
  186.  
  187.   {
  188.     register header    *hp;    /* traverses linked list */
  189.  
  190.     for (hp = last_alloca_header; hp != NULL;)
  191.       if (STACK_DIR > 0 && hp->h.deep > depth
  192.       || STACK_DIR < 0 && hp->h.deep < depth)
  193.     {
  194.       register header    *np = hp->h.next;
  195.  
  196.       free ((pointer) hp);    /* collect garbage */
  197.  
  198.       hp = np;        /* -> next header */
  199.     }
  200.       else
  201.     break;            /* rest are not deeper */
  202.  
  203.     last_alloca_header = hp;    /* -> last valid storage */
  204.   }
  205.  
  206.   if (size == 0)
  207.     return NULL;        /* no allocation required */
  208.  
  209.   /* Allocate combined header + user data storage. */
  210.  
  211.   {
  212.     register pointer    new = malloc (sizeof (header) + size);
  213.     
  214.     if (!new) return NULL;    /* out of storage */
  215.  
  216.     /* address of header */
  217.  
  218.     ((header *)new)->h.next = last_alloca_header;
  219.     ((header *)new)->h.deep = depth;
  220.  
  221.     last_alloca_header = (header *)new;
  222.  
  223.     /* User storage begins just after header. */
  224.  
  225.     return (pointer)((char *)new + sizeof(header));
  226.   }
  227. }
  228.  
  229. void init_alloca()
  230.     {
  231.     last_alloca_header = NULL;
  232.     }
  233.  
  234.